home *** CD-ROM | disk | FTP | other *** search
/ Precision Software Appli…tions Silver Collection 4 / Precision Software Applications Silver Collection Volume 4 (1993).iso / stats / chadyn.exe / YPLOT2.C < prev    next >
Text File  |  1988-12-11  |  16KB  |  609 lines
  1. /******************* (C) 1986,7,8 by JAMES A. YORKE **************************/
  2. /******************************** YPLOT2.C ***********************************/
  3. #ifdef IGNORETHIS
  4. EXTERN int      corerows INITIAL(COREROWS);
  5. EXTERN int      corecols INITIAL(CORECOLS);
  6. EXTERN int      scrnrows INITIAL(SCRNROWS);
  7. EXTERN int      scrncols INITIAL(SCRNCOLS);
  8. #define CORECOLS 960        /* Width of the internal memory's picture = */
  9.  /*  The number of bits wide =              */
  10.  /*   width in bits of the printer output   */
  11. #define SCRNCOLS 640        /* Width of the crt screen.  The program
  12.                    assumes this is no bigger than CORECOLS */
  13. #define COREROWS 68        /*  About the max num of printer lines   */
  14.  /* that are permited in 64 K      */
  15. #define SCRNROWS 200        /* height(bits) of crt screen    */
  16. #endif
  17. /* This file YPLOT.C contains routines that are tools
  18.     for plotting on the screen and in the core
  19.             James Yorke               */
  20.  
  21. /*     Routines in YPLOT.c
  22. These are routines that are essentially independent of the map being studied.
  23.  
  24. add_to_pic  in YDISK.C
  25. block_plot(x1,x2,y1,y2)
  26. boot_crt        
  27. clearp
  28. connectp(x,y)     connects x,y to x_c,y_c 
  29.     double x,y;
  30. connect2(x1,y1,x2,y2)
  31. cross(x1,y1,m,n,picnum,crossnum) reverses m dots on each side of screen point 
  32.         (row,col) and n above and below; picnum = 1 means the 
  33.         screen; = 2 means the core picture  
  34.     double x1,y1;    int m,n,picnum;
  35. definitely_erase_line()
  36. draw_box    
  37. erase_line()
  38. fetchPic
  39. fileFailureWarning()
  40. FindPixel(x1,y1,picnum) this routine puts the coordinates in the
  41.         vector COL,ROW; if picnum == 1, they are for the crt while 
  42.         if == 2 they are for the core copy 
  43.     double x1,y1;int picnum;
  44. maskdef  
  45. picOff(COLnum1,ROWnum1,COLnum2,ROWnum2)
  46.     int COLnum1,ROWnum1,COLnum2,ROWnum2;
  47. plot(x,y)       
  48. PlotComplaint
  49. PrintBoxCoordinates() if printer > 1; prints at top of screen
  50. pprint(onprint) in YPLOT2  
  51. resetDiameters
  52. reverseCore(x,y)
  53. ScreenConstants()    sets ax,bx where x = 0,00,1,2
  54. scrOff(COLnum1,ROWnum1,COLnum2,ROWnum2)
  55.     int COLnum1,ROWnum1,COLnum2,ROWnum2;
  56. int set_box             sets X_low thru Y_upp 
  57. td
  58. td0 monochrome
  59. double ticGap(dif) dif is double; called by ticMarks
  60. ticMarks() called by draw_box when ticFlag == ON 
  61.  
  62. */
  63.  
  64.  
  65. #include "yinclud.h"
  66. #define BLANK 0
  67.  
  68.  
  69. /* char far pic1[CORESIZE];   65280 = Memory size in core */
  70. extern char     far * pic1;
  71. extern char     far * pic2;
  72. extern char     far * pic4;
  73. extern char     far * pic8;
  74. extern char     one,
  75.                 two,
  76.                 four,
  77.                 eight;        /* bytes for pic arrays */
  78. extern unsigned char    byte255;
  79. extern char     printstatus;    /* set in YPRINTER.C, = status byte of printer;
  80.                    see also _bios_printer() which is a MSC
  81.                    function */
  82.  
  83.  
  84.  
  85.  
  86.  
  87. static int      Contin;        /* for interruption by hitting Esc */
  88. pprint(onprint)        /* first it initializes the printer; then it
  89.                    stores picture on disk if "disk" == 1;
  90.                    prints text header at top of paper if
  91.                    "printer" > 0 prints pic1[] using codes for
  92.                    EPSON printer; notice that if "printer" == 0
  93.                    two pictures can be printed right next to
  94.                    each other so that by plotting two pictures,
  95.                    for example an attractor for the henon map
  96.                    with vertical coord y in 0,2 and the second
  97.                    picture with y in -2,0, you wind up with a
  98.                    single double length picture with y running
  99.                    from -2,2; if you want such a picture for a
  100.                    differential equation, you should
  101.                    reinitiallize the picture before each of the
  102.                    runs so that the curves match up on the
  103.                    boundary */
  104. int     onprint;
  105. {
  106. #ifndef MAINFRAME
  107.     int     p0;
  108.     int     checkPrinter();
  109.  
  110.  
  111.     Contin = YES;
  112.     if(disk == 1)        /* send picture to disk */
  113.         td();
  114.     if(checkPrinter () == NO)
  115.         return;
  116.     fflush(stdprn);    /* dumps the computer's file buffer to printer 
  117.                 */
  118.     if(printer > 0) {
  119.         line_feed();    /* printer command */
  120.         i12print();    /* tells printer to return to regular spacing 
  121.                 */
  122.         print_text(StPrint);
  123.                 /* prints text header at top of picture */
  124.     }
  125.     iprint(printerSpacing);/* sets spacing for lines */
  126.  
  127.  /* initial lines that are blank will be skipped; Contin is used to interrupt
  128.     printing by hitting space bar  */
  129.     for(p0 = 0; (Contin == YES) && (p0 < corerows); p0++) {
  130.                 /* p0 = line number */
  131.     /* *************   Now deal with line #p0   ************************** 
  132.     */
  133.         selectPrinterColor(0);/* black */
  134.         if(printMode == EPSONBW && Contin == YES)
  135.             printScrnColor(0, p0, onprint);
  136.         else
  137.             if(printMode == EPSONCOLOR && Contin == YES)
  138.                 LQ2500 (p0, onprint);
  139.  
  140.     /* line has been printed onprint times if onprint > 0         */
  141.         line_feed();    /* printer command; needed between lines of
  142.                    picture */
  143.  
  144.     }            /* end p0 */
  145.     i12print();        /* tells printer to return to regular spacing 
  146.                 */
  147. #endif
  148. }
  149.  
  150. LQ2500 (p0, onprint)        /* this is for printing a s 8 bit high line in
  151.                    color on either an Epson LQ 2500 or LQ 2550 
  152.                 */
  153. int     p0,
  154.         onprint;
  155. {                /* note that color plane pic8 is not used */
  156.  
  157.     selectPrinterColor(1);
  158.     printScrnColor(5, p0, onprint);/* blue/violet */
  159.  
  160.     selectPrinterColor(2);    /* cyan */
  161.     printScrnColor(3, p0, onprint);
  162.  
  163.     selectPrinterColor(3);
  164.     printScrnColor(1, p0, onprint);/* blue-violet */
  165.  
  166.     selectPrinterColor(4);    /* magenta */
  167.     printScrnColor(6, p0, onprint);/* brown-yellow */
  168.  
  169.     selectPrinterColor(5);    /* red */
  170.     printScrnColor(4, p0, onprint);
  171.  
  172.     selectPrinterColor(6);
  173.     printScrnColor(2, p0, onprint);/* green */
  174.  
  175.     selectPrinterColor(0);    /* */
  176.     printScrnColor(7, p0, onprint);
  177. }
  178.  
  179.  
  180. printScrnColor(mode, p0, onprint)
  181. int     mode,
  182.         p0,
  183.         onprint;
  184. {
  185.     char    CharLine[CORECOLS],
  186.             getMX80pic();
  187.     unsigned        i,
  188.                     coord,
  189.                     blankLine;
  190.     int     cs,
  191.             keycheck();
  192.     int     prt;
  193.  
  194.  
  195.     blankLine = YES;    /* initialize as blank so far */
  196.     for(i = 0; i < corecols; i++) {/* Is line blank? */
  197.         coord = i * corerows + p0;
  198.         CharLine[i] = getMX80pic(coord, mode);
  199.         if(CharLine[i] != 0)
  200.             blankLine = NO;
  201.     }
  202.     for(prt = 1; prt == 1 || prt <= onprint; prt++) {
  203.         cs = keycheck();
  204.         if(cs == ESC || cs == ' ')
  205.             Contin = NO;
  206.                 /* space bar stops printing and returns program
  207.                    to parameter selection */
  208.  
  209.         if(blankLine == YES || Contin == NO)/* then do not print */
  210.             return;    /* terminates prt loop and we look at next line
  211.                    */
  212.         else {        /* now print line once */
  213.             print_graphics_mode();
  214.             for(i = 0; i < corecols; i++) {
  215. /*                putc(CharLine[i],stdprn);
  216.                 fflush(stdprn);
  217.                  */ C = CharLine[i];
  218.                 printChar();
  219.             }
  220.             carriage_return();
  221.         }        /* end else */
  222.     }            /* end prt */
  223. }
  224. HPLine(p0)            /* this is for printing an 8 bit high line in
  225.                    color */
  226. int     p0;
  227. {
  228.     int     bit;
  229.  
  230.     rasterColorPlanes(4);    /* Esc*r4U */
  231. /* Esc*r0A */
  232.     setRasterMode();    /* =Esc*r0A, specifies graphics start at left
  233.                    margin */
  234.     for(bit = 0; bit < 8; bit++) {
  235.         set90RasterMode();
  236.         rasterByte(pic1 + p0, bit);
  237.         set90RasterMode();
  238.         rasterByte(pic2 + p0, bit);
  239.         set90RasterMode();
  240.         rasterByte(pic4 + p0, bit);
  241.         setLast90RasterMode();
  242.         rasterByte(pic8 + p0, bit);
  243.     }
  244.     exitRasterMode();
  245. }
  246.  
  247. HPColorRaster(pic, bit)    /* this is for specifying a 1-bit-high line of
  248.                    1 color plane */
  249. int     bit;
  250. char   *pic;
  251. {
  252.     int     j;
  253.     unsigned        plus = 8 * corerows;
  254.  
  255.     for(j = 0; j < 90; j++, pic += plus) {
  256.         rasterByte(pic, bit);
  257.         printChar();
  258.     }
  259. }
  260.  
  261. rasterByte(pic, bit)        /* This takes the bit number "bit" out of 8
  262.                    bytes that start at address pic and combine
  263.                    them into one byte which is sent to the
  264.                    printer */
  265. char   *pic;
  266. int     bit;
  267. {
  268.     unsigned char   B = mask[bit];
  269.  
  270.     C = 0;
  271.     if(((*pic) & B) != 0)
  272.         C = 1;
  273.     pic += corerows;
  274.     if(((*pic) & B) != 0)
  275.         C += 2;
  276.     pic += corerows;
  277.     if(((*pic) & B) != 0)
  278.         C += 4;
  279.     pic += corerows;
  280.     if(((*pic) & B) != 0)
  281.         C += 8;
  282.     pic += corerows;
  283.     if(((*pic) & B) != 0)
  284.         C += 16;
  285.     pic += corerows;
  286.     if(((*pic) & B) != 0)
  287.         C += 32;
  288.     pic += corerows;
  289.     if(((*pic) & B) != 0)
  290.         C += 64;
  291.     if(((*(pic + 7)) & B) != 0)
  292.         C += 128;
  293.     printChar();
  294.     return;
  295. }
  296.  
  297. rasterColorPlanes(c)        /* HP PAINTJET :number of color planes */
  298. int     c;
  299. {
  300.     C = ESC;
  301.     printChar();
  302.     C = '*';
  303.     printChar();
  304.     C = 'r';
  305.     printChar();
  306.     C = '0' + c;
  307.     printChar();
  308.     C = 'U';
  309.     printChar();
  310. }
  311. /* Esc*r0A */
  312. setRasterMode() {        /* HP PAINTJET  */
  313.     C = ESC;
  314.     printChar();
  315.     C = '*';
  316.     printChar();
  317.     C = 'r';
  318.     printChar();
  319.     C = '0';
  320.     printChar();
  321.     C = 'A';
  322.     printChar();
  323. }
  324.  
  325. exitRasterMode() {        /* HP PAINTJET  */
  326.     C = ESC;
  327.     printChar();
  328.     C = '*';
  329.     printChar();
  330.     C = 'r';
  331.     printChar();
  332.     C = 'B';
  333.     printChar();
  334. }
  335.  
  336. set90RasterMode() {        /* HP PAINTJET: says 90 bytes for each color
  337.                    plane; this or setLastRasterMode must preced
  338.                    each line of bytes  */
  339.     C = ESC;
  340.     printChar();
  341.     C = '*';
  342.     printChar();
  343.     C = 'b';
  344.     printChar();
  345.     C = '9';
  346.     printChar();
  347.     C = '0';
  348.     printChar();
  349.     C = 'V';
  350.     printChar();
  351. }
  352.  
  353. setLast90RasterMode() {    /* HP PAINTJET: says 90 bytes for last color
  354.                    plane  */
  355.     C = ESC;
  356.     printChar();
  357.     C = '*';
  358.     printChar();
  359.     C = 'b';
  360.     printChar();
  361.     C = '9';
  362.     printChar();
  363.     C = '0';
  364.     printChar();
  365.     C = 'W';
  366.     printChar();
  367. }
  368.  
  369. char    getMX80pic(coord, mode)/* gets one character */
  370. unsigned        coord,
  371.                 mode;
  372. {
  373.     char    pc1,
  374.             pc2,
  375.             pc4,
  376.             pc8;
  377.  
  378.     if(mode == 0) {
  379.         if(colorPlanes >= 1)
  380.             pc1 = pic1[coord];
  381.         else
  382.             pc1 = 0;
  383.         if(colorPlanes >= 2)
  384.             pc2 = pic2[coord];
  385.         else
  386.             pc2 = 0;
  387.         if(colorPlanes >= 3)
  388.             pc4 = pic4[coord];
  389.         else
  390.             pc4 = 0;
  391.         if(colorPlanes >= 4)
  392.             pc8 = pic8[coord];
  393.         else
  394.             pc8 = 0;
  395.         return(pc1 | pc2 | pc4 | pc8);
  396.     }
  397.     if(mode == 1)
  398.         return((pic1[coord] & ~pic2[coord]) & ~pic4[coord]);/* 1 */
  399.     if(mode == 2)
  400.         return((~pic1[coord] & pic2[coord]) & ~pic4[coord]);/* 2 */
  401.     if(mode == 3)
  402.         return((pic1[coord] & pic2[coord]) & ~pic4[coord]);/* 3 */
  403.     if(mode == 4)
  404.         return((~pic1[coord] & ~pic2[coord]) & pic4[coord]);/* 4 */
  405.     if(mode == 5)
  406.         return((pic1[coord] & ~pic2[coord]) & pic4[coord]);/* 5 */
  407.     if(mode == 6)
  408.         return((~pic1[coord] & pic2[coord]) & pic4[coord]);/* 6 */
  409.     if(mode == 7)
  410.         return((pic1[coord] & pic2[coord]) & pic4[coord]);/* 7 */
  411.     return((char) 0);    /* dumby return */
  412. }
  413.  
  414. #ifndef MAINFRAME
  415.  
  416. int     checkPrinter() {
  417.     int     printerstatus;
  418.     char    ch;
  419.     char       what_me_worry();
  420.     int     keycheck();
  421.  
  422.     printerStatus(1);    /* initializes the printer */
  423.     printerStatus(2);    /* returns status byte; it returns an integer
  424.                    (but not here); meaning of bit: 7    printer
  425.                    busy 6    Acknowledge 5    out of paper 4
  426.                    selected 3     I/O error 2,1    not used 0 
  427.                    timed out         */
  428.  
  429.     if(printstatus != 0)
  430.         PRINT
  431.             "printer status = %d; bit# 0= %d 1= %d 2= %d 3= %d 4= %d 5= %d 6 %d 7 %d\n"
  432.             ,printerstatus = printstatus
  433.             ,printerstatus = printstatus & mask[7]
  434.             ,printerstatus = printstatus & mask[6]
  435.             ,printerstatus = printstatus & mask[5]
  436.             ,printerstatus = printstatus & mask[4]
  437.             ,printerstatus = printstatus & mask[3]
  438.             ,printerstatus = printstatus & mask[2]
  439.             ,printerstatus = printstatus & mask[1]
  440.             ,printerstatus = printstatus & mask[0]);
  441.  
  442.     printerstatus = printstatus & mask[4];
  443.     if(printerstatus != 0) {/* this is called bit 3; they seem to count
  444.                    from the other end; */
  445.         PRINT
  446.             "WARNING: printer I/O error detected; perhaps printer is off; \n");
  447.         ch = what_me_worry();/* gives warning and gets response */
  448.         if(ch != 'y' && ch != 'Y')
  449.             return(NO);
  450.     }
  451.     printerstatus = printstatus & mask[2];
  452.     if(printerstatus != 0) {/*  called bit 5 */
  453.         PRINT
  454.             "WARNING: printer error; perhaps printer is out of paper.\n");
  455.         ch = what_me_worry();/* gives warning and gets response */
  456.         PRINT
  457.             "** %c **\n", ch);
  458.         if(ch != 'y' && ch != 'Y')
  459.             return(NO);
  460.     }
  461.     return(YES);
  462. }
  463.  
  464.  
  465. char    what_me_worry() {    /* called in case a problem with the printer
  466.                    has been detected */
  467.             PRINT
  468. "Proceed with attempt to print only if picture is stored; program might  \n"
  469.     );
  470.     PRINT
  471. "hang up. DO YOU WANT TO PROCEED WITH PRINT ATTEMPT? enter Y or N:\n");
  472.     return(ci ());
  473. }
  474.  
  475. setRGBColor()/* called by 'Q' for VGA only; 
  476.         first enter color number and the 3 shades; */ 
  477. {
  478.     char * text;
  479.     long Color;
  480.     int cnum1 = -1;
  481.     int cnum2 = -1,colnum;/* color nubers */
  482.     int r1,r2=0,b1,b2=0,g1,g2=0;/* shades */
  483.     double f,g;
  484.  
  485.     text = 
  486. "Enter another (with larger color number);program will interpolate between\n";
  487.  
  488.     if (SCREEN && printer > 1)
  489.     {
  490.         displayColors(.0,.1);
  491.         PRINT 
  492. "\nEnter color number (< %d) and red, green and blue shades (all < 64) \n",
  493.             numColors);
  494.     }
  495.     colnum = -1;
  496.     Enter4Int(&colnum,&rColor,&gColor,&bColor); 
  497.     Color = rColor + gColor*(_GREEN/_RED) + bColor*(_BLUE/_RED);
  498.     _remappalette(colnum,Color);/*notice spelling:pp has special meaning */
  499.  
  500.         for(;;)
  501.         {
  502.         cnum1 = colnum;
  503.         if (cnum1 < 0)
  504.             return; /* nothing is set */
  505.         r1 = rColor;
  506.         g1 = gColor;
  507.         b1 = bColor;
  508.     
  509.         scr_rowcol(0,0);
  510.         if (SCREEN)
  511.             PRINT text);
  512.         if (SCREEN)
  513.             PRINT 
  514. "YOU MUST Hit <Enter> TO TERMINATE COLOR SPECIFICATION \n");
  515.         if (SCREEN)
  516.             PRINT text);
  517.         Enter4Int(&cnum2,&r2,&g2,&b2); 
  518.  
  519.  
  520.         if (cnum2 <=  cnum1)
  521.             return; /* nothing more is set */
  522.         g = cnum2 - cnum1;
  523.         for (colnum = cnum1; colnum <= cnum2 ;colnum++)
  524.         {
  525.             f = (cnum2 - colnum)/g;
  526.             rColor = (f*r1 + (1-f)*r2);
  527.             gColor = (f*g1 + (1-f)*g2);
  528.             bColor = (f*b1 + (1-f)*b2);
  529.             Color = 
  530.                rColor + bColor*(_BLUE/_RED) + gColor*(_GREEN/_RED);
  531.             displayColors(.0,.1);
  532.             _remappalette(colnum,Color);
  533.             if (numColors == 255)
  534.                 scr_rowcol(0,0);
  535.         }
  536.         if (cnum2 ==  numColors)
  537.             return; /* nothing more can be set */
  538.         }
  539. }
  540.  
  541. displayColors(f0,f1)/* f0 and f1 are in 0 to 1 and are the fractions of the 
  542.         vertical scale (from 0 at bottom to 1.0 at top) that the 
  543.         color bars will occupy; this is screen only, not core picture*/
  544.     double f0,f1;
  545. {
  546.     double x1,x2,y1,y2;
  547.     double f;
  548.     unsigned k;
  549.  
  550.     y1 = (1-f0)*Y_lower+f0*Y_upper;
  551.     y2 = (1-f1)*Y_lower+f1*Y_upper;
  552.  
  553.     for (k=0; k<numColors; k++)/* display 16 colors */
  554.     {
  555.         _setcolor(k);
  556.         f = k/((double)numColors);
  557.         x1 = (1-f)*X_lower + f*X_upper;
  558.         f = (k+1)/((double)numColors);
  559.         x2 = (1-f)*X_lower + f*X_upper;
  560.         scrnBlock_plot(x1,x2,y1,y2);
  561.     }
  562.     _setcolor(color);
  563. }
  564. scrnBlock_plot(x1,x2,y1,y2)
  565.     double x1,x2,y1,y2;
  566. {
  567.     unsigned        coord;
  568.     int     COLnum1,
  569.             COLnum2,
  570.             ROWnum1,
  571.             ROWnum2;
  572.  
  573.     FindPixel(x1,y1, SCRN);/*sets COL and ROW */
  574.     COLnum1 = COL;
  575.     ROWnum1 = ROW;
  576.     FindPixel(x2, y2, SCRN);
  577.     COLnum2 = COL;
  578.     ROWnum2 = ROW;
  579.  
  580.     _rectangle(_GFILLINTERIOR,COLnum1,ROWnum1,COLnum2,ROWnum2);
  581. #ifdef IGNORE
  582.     for(COL = COLnum1; COL < COLnum2; COL++)/* COL is an int */
  583.         for(ROW = ROWnum1; ROW < ROWnum2; ROW++) 
  584.             setPixel(COL, ROW, k);
  585. #endif /*IGNORE */
  586. }
  587.  
  588.  
  589. #endif /* ifndef MAINFRAME */
  590. /* universal color values: 
  591. #define _BLACK          0x000000L  0 0 0
  592. #define _BLUE           0x2a0000L  2 0 0 where 2 = 42
  593. #define _GREEN          0x002a00L  0 2 0
  594. #define _CYAN           0x2a2a00L  2 2 0
  595. #define _RED            0x00002aL  0 0 2
  596. #define _MAGENTA        0x2a002aL  2 0 2
  597. #define _BROWN          0x00152aL  0 1 2 where 1 = 21
  598. #define _WHITE          0x2a2a2aL  2 2 2
  599. #define _GRAY           0x151515L  1 1 1
  600. #define _LIGHTBLUE      0x3F1515L  3 1 1 where 3 = 63
  601. #define _LIGHTGREEN     0x153f15L  1 3 1
  602. #define _LIGHTCYAN      0x3f3f15L  3 3 1
  603. #define _LIGHTRED       0x15153fL  1 1 3
  604. #define _LIGHTMAGENTA   0x3f153fL  3 1 3
  605. #define _LIGHTYELLOW    0x153f3fL  1 3 3
  606. #define _BRIGHTWHITE    0x3f3f3fL  3 3 3
  607. */
  608.  
  609.